function processScanFlatMode(gCode, imageData, gcodeParams) {
    // if (gcodeParams.scanDir === 'X') {
        processX(gCode, imageData, gcodeParams)
    // } else {
    //     processY(gCode, imageData, gcodeParams);
    // }
}

function processX(gCode, image, gcp) {
    let width = image.width;
    let height = image.height;
    let xSize = gcp.laserXBeamSize;
    let ySize = gcp.laserYBeamSize;
    let isRelativeCoord = gcp.isRelativeCoord;

    gCode.speed(0);
    gCode.rapid({x: gcp.xOffset, y: (height - 1) * ySize + gcp.yOffset});

    let positionCount = 0;
    let lineCount = 0;
    let didLaserToggle = false; // 激光开关状态
    let changeLaserPower = false; // 是否需要切换激光器功率
    let powerValue = 0;
    let maxGray = gcp.maxGray; // 最大灰度值
    if (!gcp.gray255Power && maxGray === 255) maxGray -= 1; // 灰度范围为 0 - 254,, 255不打标
    let grayscale = maxGray - gcp.minGray; // 灰度范围
    let lastGrayscale = maxGray + 1; // 上一个灰度值，默认白色，不打

    let ratioLaser = (gcp.laserPowerMaxS - gcp.laserPowerMinS) / grayscale; // 计算激光器功率比例
    let lastIndex = {x: 0 , y: height - 1}; 

    let direction = 0; // 前进
    let directionToggle = 1; // 方向切换
    let serpentine = gcp.serpentine; // 是否启用双向扫描
    if (serpentine) {
        directionToggle = 2;
    }
    let yParity = (height - 1) % 2;

    // for (let y = 0; y < height; y++) {
    for (let y = height - 1; y >= 0; y--) { // 从左上角开始扫描
        direction = (y + yParity) % directionToggle; // 切换方向
        let start, end, step;
        if (direction === 0) {
            start = 0;
            end = width;
            step = 1;
        } else {
            start = width - 1;
            end = -1;
            step = -1;
        }
        for (let x = start; x != end; x += step) {  // 遍历每一个像素点
            let grayscale = image.data[x][y]; // 获取灰度值
            changeLaserPower = (grayscale !== lastGrayscale); // 是否需要更新激光值
            if (changeLaserPower) { // 如果上一个灰度值和当前灰度值差值大于灰度精度，则需要切换激光器功率
                didLaserToggle = true; // 这一行相较于第一个点的功率有变化
                if (positionCount !== 0) { // 如果有计数直 （即上一个功率值需要移动 positionCount 个像素点）
                    if (lineCount > 0) {
                        gCode.speed(0); // 关光;
                        lastGrayscale =  maxGray + 1; // 关闭激光器后，更新灰度值信息
                        if (isRelativeCoord) {
                            gCode.linear({x: (start - lastIndex.x) * xSize, y: ( - lineCount) * ySize});
                            gCode.speed(powerValue)
                            gCode.linear({x: positionCount * xSize});
                        }else {
                            gCode.linear({x: start * xSize + gcp.xOffset , y: y * ySize + gcp.yOffset});  
                            gCode.speed(powerValue)
                            gCode.linear({x: positionCount * xSize + gcp.xOffset});
                        } 
                        lastIndex.x = start + positionCount;
                        lastIndex.y = y;
                        lineCount = 0;
                    } else {
                        if (isRelativeCoord) {
                            gCode.linear({x: positionCount * xSize}); 
                        }else {
                            gCode.linear({x: (lastIndex.x + positionCount) * xSize + gcp.xOffset});
                            // gCode.linear({x: (lastIndex.x + positionCount) * xSize + gcp.xOffset, y: (y + 1) * ySize + gcp.yOffset});
                        } 
                        lastIndex.x += positionCount;
                    }
                    positionCount = 0; // 移动完计数直归零
                    
                }
                lastGrayscale = grayscale; // 更新灰度值信息
                
                powerValue = grayscale < maxGray + 1 
                            ? Math.floor(ratioLaser * (maxGray - grayscale) + gcp.laserPowerMinS)
                            : 0; // 计算新的激光器激光功率
                if(lineCount === 0) 
                    gCode.speed(powerValue); // 设置新的激光器激光功率
            }
            positionCount += step;
        }
        // 一行扫描完成，检查是否需要关闭激光器，并移动到新一行
        if (positionCount !== 0 && didLaserToggle ) {
            // 移动到末尾
            if (powerValue !== 0){
                if (isRelativeCoord) {
                    gCode.linear({x: (end - lastIndex.x) * xSize})
                }else {
                    gCode.linear({x: end * xSize + gcp.xOffset});
                    // gCode.linear({x: end * xSize + gcp.xOffset, y: (y + 1) * ySize + gcp.yOffset});
                } 
                lastIndex.x = end;
                lastIndex.y = y;
                gCode.speed(0); // 关光
            }
            
            didLaserToggle = false;
            lastGrayscale =  maxGray + 1; // 关闭激光器后，更新灰度值信息

            // 换行
            if (direction === 0 && serpentine){ // 双向，准备换向
                if (isRelativeCoord) {
                    gCode.linear({X: (end - lastIndex.x) * xSize, y: ( - lineCount - 1) * ySize});
                }else {
                    gCode.linear({x: end * xSize + gcp.xOffset, y: (lastIndex.y - lineCount - 1)  * ySize + gcp.yOffset});
                } 
                lastIndex.x = end;
            } else { // 单向，移动到新的一行的开头
                if (isRelativeCoord) {
                    gCode.linear({x: (start - lastIndex.x) * xSize, y: ( - lineCount - 1) * ySize});
                }else {
                    gCode.linear({x: start * xSize + gcp.xOffset, y: (y - 1) * ySize + gcp.yOffset});
                } 
                lastIndex.x = start;
            }
            lineCount = 0;
            lastIndex.y = y - 1;
            
        } else {
            lineCount++;
        }

        changeLaserPower = false;
        positionCount = 0;
    }
    gCode.laserOff(); // 关激光
    if (isRelativeCoord) { // 回零
        gCode.rapid({x: -lastIndex.x * xSize - gcp.xOffset, y: -lastIndex.y * ySize - gcp.yOffset});
    }else {
        gCode.rapid({x: 0, y: 0});
    }   
}

// function processY(gCode, image, gcp) {
//     let width = image.width;
//     let height = image.height;
//     let xSize = gcp.laserXBeamSize;
//     let ySize = gcp.laserYBeamSize;
//     let isRelativeCoord = gcp.isRelativeCoord;

//     gcodeInitialize(gCode, gcp);
//     gCode.speed(0);
//     gCode.rapid({x:  gcp.xOffset, y: (height - 1) * ySize + gcp.yOffset});
    
//     let positionCount = 0;
//     let lineCount = 0;
//     let didLaserToggle = false; // 激光开关状态
//     let changeLaserPower = false; // 是否需要切换激光器功率
//     let powerValue = 0;
//     let maxGray = gcp.maxGray; // 最大灰度值
//     if (!gcp.gray255Power && maxGray === 255) maxGray -= 1; // 灰度范围为 0 - 254,, 255不打标
//     let grayscale = maxGray - gcp.minGray; // 灰度范围
//     let lastGrayscale = maxGray + 1; // 上一个灰度值

//     let ratioLaser = (gcp.laserPowerMaxS - gcp.laserPowerMinS) / grayscale; // 计算激光器功率比例
//     let lastIndex = {x: 0 , y: height - 1}; 

//     let direction = 0; // 前进
//     let directionToggle = 1; // 方向切换
//     let serpentine = gcp.serpentine; // 是否启用双向扫描
//     if (serpentine) {
//         directionToggle = 2;
//     }

//     for (let x = 0; x < width; x++) {  // 从左上角开始扫描
//         direction = x % directionToggle; // 切换方向
//         let start, end, step;
//         if (direction === 0) {
//             start = height - 1;
//             end = -1;
//             step = -1;
//         } else {
//             start = 0;
//             end = height;
//             step = 1;
//         }

//         for (let y = start; y != end; y += step) {
//             let grayscale = image.data[x][y]; // 获取灰度值
//             changeLaserPower = (grayscale !== lastGrayscale); // 是否需要更新激光值
//             if (changeLaserPower) { // 如果上一个灰度值和当前灰度值差值大于灰度精度，则需要切换激光器功率
//                 didLaserToggle = true; // 这一行相较于第一个点的功率有变化

//                 if (positionCount !== 0) { // 如果有计数直 （即上一个功率值需要移动 positionCount 个像素点）
//                     if (lineCount > 0) {
//                         gCode.speed(0); // 关光
//                         didLaserToggle = false;
//                         lastGrayscale =  maxGray + 1; // 关闭激光器后，更新灰度值信息
//                         if (isRelativeCoord) {
//                             gCode.rapid({x: lineCount * xSize, y: (start - lastIndex.y) * ySize});
//                             gCode.linear({y: positionCount * ySize});
//                         }else {
//                             gCode.rapid({x: x * xSize + gcp.xOffset , y: start * ySize + gcp.yOffset});  
//                             gCode.linear({y: positionCount * ySize + gcp.YOffset});
//                         } 
//                         lastIndex.x = x;
//                         lastIndex.y = start + positionCount;
//                         lineCount = 0;
//                     } else {
//                         if (isRelativeCoord) {
//                             gCode.linear({y: positionCount * ySize}); 
//                         }else {
//                             gCode.linear({y: (lastIndex.y + positionCount) * ySize + gcp.yOffset});
//                         } 
//                         lastIndex.y += positionCount;
//                     }
//                     positionCount = 0; // 移动完计数直归零
//                 }
//                 lastGrayscale = grayscale; // 更新灰度值信息
//                 powerValue = grayscale < maxGray + 1 
//                             ? Math.floor(ratioLaser * (maxGray - grayscale) + gcp.laserPowerMinS)
//                             : 0; // 计算新的激光器激光功率
//                 gCode.speed(powerValue); // 设置新的激光器激光功率

//             }
//             positionCount += step;
//         }
//         // 一行扫描完成，检查是否需要关闭激光器，并移动到新一行
//         if (positionCount !== 0 && didLaserToggle) {
//             // 移动到末尾
//             if (powerValue !== 0){
//                 if (isRelativeCoord) {
//                     gCode.linear({y: (end - lastIndex.y) * ySize})
//                 }else {
//                     gCode.linear({y: end * ySize + gcp.yOffset});
//                     // gCode.linear({x: end * xSize + gcp.xOffset, y: (y + 1) * ySize + gcp.yOffset});
//                 } 
//                 lastIndex.x = x;
//                 lastIndex.y = end;
//                 gCode.speed(0); // 关光
//             }
            
//             didLaserToggle = false;
//             lastGrayscale =  maxGray + 1; // 关闭激光器后，更新灰度值信息

//             // TODO: 换行
//             if (direction === 0 && serpentine){ // 双向，准备换向
//                 if (isRelativeCoord) {
//                     gCode.rapid({X: (end - lastIndex.x) * xSize, y: ( - lineCount - 1) * ySize});
//                 }else {
//                     gCode.rapid({x: (x + 1) * xSize + gcp.xOffset, y: end  * ySize + gcp.yOffset});
//                 } 
//                 lastIndex.y = end;
//             } else { // 单向，移动到新的一行的开头
//                 if (isRelativeCoord) {
//                     gCode.rapid({x: (start - lastIndex.x) * xSize, y: ( - lineCount - 1) * ySize});
//                 }else {
//                     gCode.rapid({x: (x + 1) * xSize + gcp.xOffset, y: start * ySize + gcp.yOffset});
//                 } 
//                 lastIndex.y = start;
//             }
//             lineCount = 0;
//             lastIndex.x = x + 1;
            
//         } else {
//             lineCount++;
//         }

//         changeLaserPower = false;
//         positionCount = 0;
//     }
//     gCode.laserOff(); // 关激光
//     if (isRelativeCoord) { // 回零
//         gCode.rapid({x: -lastIndex.x * xSize - gcp.xOffset, y: -lastIndex.y * ySize - gcp.yOffset});
//     }else {
//         gCode.rapid({x: 0, y: 0});
//     }   
//     gCode.finishProgram();// 程序结束
// }


module.exports = { processScanFlatMode };